﻿package frEngine.animateControler.particleControler.animate
{
    import __AS3__.vec.*;
    import baseEngine.core.*;
    import com.gengine.utils.pools.*;
    import flash.geom.*;
    import frEngine.animateControler.particleControler.*;
    import frEngine.core.*;
    import frEngine.math.*;
    import frEngine.shader.*;
    import frEngine.shader.filters.*;
    import frEngine.shader.registType.*;
    import frEngine.util.*;

    public class ParticleStatus extends Object
    {
        private var inertiaValue:Number;
        public var useEndPoint:Boolean;
        public var tailEnabled:Boolean;
        public var particleList:Vector.<ParticleItem>;
        public var useSelfRotate:Boolean = false;
        public var openUvOffset:Boolean = false;
        public var isFaceCamera:Boolean;
        private var _curFrame:int;
        public var globalPos:Vector3D;
        public var gRotate:Quaternion;
        private var _perPEmiterNeedFrame:Number;
        private var _animList:Vector.<IParticleAnimate>;
        private var _particleParams:ParticleParams;
        private var _data1:Vector.<Number>;
        private var _data2:Vector.<Number>;
        private var _useTimeGrowth:Boolean;
        private static const animPropertyName:Array = initAnimList();
        public static const multyply0:Number = 4;
        public static const multyply1:Number = 100;
        public static const multyply2:Number = 1000;
        public static const multyply3:Number = 10;
        public static const maxNum:int = 45;
        private static const pool:Vector.<ParticleItem> = new Vector.<ParticleItem>;

        public function ParticleStatus()
        {
            this.particleList = new Vector.<ParticleItem>;
            this._animList = new Vector.<IParticleAnimate>;
            this._data1 = new Vector.<Number>;
            this._data2 = new Vector.<Number>;
            return;
        }// end function

        public function reinit(param1:ParticleParams) : void
        {
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:ParticleItem = null;
            var _loc_11:int = 0;
            var _loc_14:IParticleAnimate = null;
            var _loc_15:Vector.<Number> = null;
            var _loc_16:int = 0;
            var _loc_17:int = 0;
            var _loc_18:IParticleAnimate = null;
            var _loc_19:Boolean = false;
            this.useSelfRotate = false;
            this.openUvOffset = false;
            this._particleParams = param1;
            this._useTimeGrowth = this._particleParams.useTimeGrowth;
            var _loc_2:* = param1.total_number;
            this.inertiaValue = this._particleParams.inertiaValue;
            this.tailEnabled = this._particleParams.tailEnabled;
            this.useEndPoint = this._particleParams.useEndPoint;
            var _loc_3:* = param1.numOfmeshVertex;
            this.isFaceCamera = this._particleParams.faceCamera;
            this._perPEmiterNeedFrame = this._particleParams.perParticleEmitterTime;
            var _loc_20:* = _loc_2 * 4;
            this._data2.length = _loc_2 * 4;
            this._data1.length = _loc_20;
            var _loc_4:* = param1.surfaceData["" + FilterName_ID.PARAM0_ID + ":4:true"];
            var _loc_5:* = ParticleStatus.pool;
            var _loc_6:* = param1.surfaceData["" + FilterName_ID.PARAM1_ID + ":3:true"];
            var _loc_7:* = param1.numOfmeshVertex;
            this.dispose();
            if (_loc_2 > maxNum)
            {
                _loc_15 = param1.surfaceData["" + FilterName_ID.POSITION_ID + ":4:true"];
                _loc_8 = maxNum;
                while (_loc_8 < _loc_2)
                {
                    
                    _loc_9 = _loc_8 * _loc_3 * 4 + 3;
                    _loc_16 = _loc_8 - maxNum;
                    _loc_17 = 0;
                    while (_loc_17 < _loc_3)
                    {
                        
                        _loc_15[_loc_9] = _loc_16;
                        _loc_9 = _loc_9 + 4;
                        _loc_17++;
                    }
                    _loc_8++;
                }
            }
            var _loc_12:* = HelpUtils.getRandomArr(this._particleParams.seed, _loc_2, 12);
            if (_loc_5.length >= _loc_2)
            {
                _loc_8 = 0;
                while (_loc_8 < _loc_2)
                {
                    
                    _loc_9 = _loc_8 * _loc_3 * 4;
                    var _loc_20:* = _loc_5.shift();
                    _loc_10 = _loc_5.shift();
                    this.particleList[_loc_8] = _loc_20;
                    _loc_10.emmiteFrame = _loc_4[_loc_9] * this._perPEmiterNeedFrame;
                    _loc_10.randomValue = _loc_12[_loc_8];
                    _loc_10.index = _loc_8;
                    _loc_10.life = _loc_4[(_loc_9 + 1)];
                    _loc_11 = _loc_7 * _loc_8 * 3;
                    _loc_10.posOffset.setTo(_loc_6[_loc_11], _loc_6[(_loc_11 + 1)], _loc_6[_loc_11 + 2]);
                    _loc_8++;
                }
            }
            else
            {
                _loc_8 = 0;
                while (_loc_8 < _loc_2)
                {
                    
                    _loc_9 = _loc_8 * _loc_3 * 4;
                    var _loc_20:* = new ParticleItem();
                    _loc_10 = new ParticleItem();
                    this.particleList[_loc_8] = _loc_20;
                    _loc_10.emmiteFrame = _loc_4[_loc_9] * this._perPEmiterNeedFrame;
                    _loc_10.randomValue = _loc_12[_loc_8];
                    _loc_10.life = _loc_4[(_loc_9 + 1)];
                    _loc_10.index = _loc_8;
                    _loc_11 = _loc_7 * _loc_8 * 3;
                    _loc_10.posOffset.setTo(_loc_6[_loc_11], _loc_6[(_loc_11 + 1)], _loc_6[_loc_11 + 2]);
                    _loc_8++;
                }
            }
            var _loc_13:* = this._animList.length;
            _loc_8 = 0;
            while (_loc_8 < _loc_13)
            {
                
                _loc_14 = this._animList[_loc_8];
                ObjectPool.disposeObject(_loc_14, _loc_14.objClass);
                _loc_8++;
            }
            this._animList.length = 0;
            _loc_13 = animPropertyName.length;
            _loc_8 = 0;
            while (_loc_8 < _loc_13)
            {
                
                _loc_18 = animPropertyName[_loc_8];
                _loc_19 = _loc_18.canOpen(this._particleParams);
                if (_loc_19)
                {
                    _loc_14 = ObjectPool.getObject(_loc_18.objClass) as IParticleAnimate;
                    _loc_14.init(this, this._particleParams);
                    this._animList.push(_loc_14);
                }
                _loc_8++;
            }
            return;
        }// end function

        public function dispose() : void
        {
            var _loc_4:ParticleItem = null;
            var _loc_1:* = this.particleList.length;
            var _loc_2:* = ParticleStatus.pool;
            var _loc_3:int = 0;
            while (_loc_3 < _loc_1)
            {
                
                _loc_4 = this.particleList[_loc_3];
                _loc_4.reset(true);
                _loc_2.push(_loc_4);
                _loc_3++;
            }
            this.particleList.length = 0;
            this.globalPos = null;
            this.gRotate = null;
            return;
        }// end function

        public function reset(param1:Boolean) : void
        {
            var _loc_4:ParticleItem = null;
            var _loc_2:* = this.particleList.length;
            var _loc_3:int = 0;
            while (_loc_3 < _loc_2)
            {
                
                _loc_4 = this.particleList[_loc_3];
                _loc_4.reset(param1);
                _loc_3++;
            }
            return;
        }// end function

        private function updateInertia() : void
        {
            var _loc_6:ParticleItem = null;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:Quaternion = null;
            var _loc_10:Quaternion = null;
            var _loc_11:Vector3D = null;
            var _loc_12:Vector3D = null;
            var _loc_15:Number = NaN;
            var _loc_16:Vector3D = null;
            var _loc_1:int = 0;
            var _loc_2:* = multyply0;
            var _loc_3:* = multyply1;
            var _loc_4:* = multyply2;
            var _loc_5:* = multyply3;
            var _loc_13:* = this.particleList.length;
            var _loc_14:* = _loc_13 > maxNum ? (maxNum) : (_loc_13);
            _loc_8 = 0;
            while (_loc_8 < _loc_14)
            {
                
                _loc_6 = this.particleList[_loc_8];
                _loc_7 = _loc_6.visible;
                _loc_9 = _loc_6.startRotate;
                _loc_10 = _loc_6.resultRotate2;
                _loc_11 = _loc_6.resultPos;
                _loc_12 = _loc_6.startPos;
                _loc_16 = _loc_6.inertiaDirection;
                this._data1[_loc_1] = int(_loc_11.x * _loc_5) * _loc_2 + _loc_9.x + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_11.y * _loc_5) * _loc_2 + _loc_9.y + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_11.z * _loc_5) * _loc_2 + _loc_9.z + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_6.uOffset * _loc_4) * _loc_2 + _loc_6.size * _loc_7 + 1;
                _loc_1++;
                _loc_15 = _loc_6.curFrame * this.inertiaValue;
                this._data1[_loc_1] = int((_loc_12.x + _loc_16.x * _loc_15) * _loc_5) * _loc_2 + _loc_10.x + 1;
                _loc_1++;
                this._data1[_loc_1] = int((_loc_12.y + _loc_16.y * _loc_15) * _loc_5) * _loc_2 + _loc_10.y + 1;
                _loc_1++;
                this._data1[_loc_1] = int((_loc_12.z + _loc_16.z * _loc_15) * _loc_5) * _loc_2 + _loc_10.z + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_6.vOffset * _loc_4) * _loc_2 + _loc_10.w + 1;
                _loc_1++;
                _loc_8++;
            }
            var _loc_17:* = _loc_13 - maxNum;
            if (_loc_17 <= 0)
            {
                return;
            }
            _loc_1 = 0;
            _loc_13 = _loc_13 > maxNum * 2 ? (maxNum * 2) : (_loc_13);
            _loc_8 = _loc_14;
            while (_loc_8 < _loc_13)
            {
                
                _loc_6 = this.particleList[_loc_8];
                _loc_7 = _loc_6.visible;
                _loc_9 = _loc_6.startRotate;
                _loc_10 = _loc_6.resultRotate2;
                _loc_11 = _loc_6.resultPos;
                _loc_12 = _loc_6.startPos;
                this._data2[_loc_1] = int(_loc_11.x * _loc_5) * _loc_2 + _loc_9.x + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_11.y * _loc_5) * _loc_2 + _loc_9.y + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_11.z * _loc_5) * _loc_2 + _loc_9.z + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_6.uOffset * _loc_4) * _loc_2 + _loc_6.size * _loc_7 + 1;
                _loc_1++;
                _loc_15 = _loc_6.curFrame * this.inertiaValue;
                this._data2[_loc_1] = int((_loc_12.x + _loc_16.x * _loc_15) * _loc_5) * _loc_2 + _loc_10.x + 1;
                _loc_1++;
                this._data2[_loc_1] = int((_loc_12.y + _loc_16.y * _loc_15) * _loc_5) * _loc_2 + _loc_10.y + 1;
                _loc_1++;
                this._data2[_loc_1] = int((_loc_12.z + _loc_16.z * _loc_15) * _loc_5) * _loc_2 + _loc_10.z + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_6.vOffset * _loc_4) * _loc_2 + _loc_10.w + 1;
                _loc_1++;
                _loc_8++;
            }
            return;
        }// end function

        private function updateNotInertia() : void
        {
            var _loc_6:ParticleItem = null;
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:Quaternion = null;
            var _loc_10:Quaternion = null;
            var _loc_11:Vector3D = null;
            var _loc_12:Vector3D = null;
            var _loc_15:Number = NaN;
            var _loc_1:int = 0;
            var _loc_2:* = multyply0;
            var _loc_3:* = multyply1;
            var _loc_4:* = multyply2;
            var _loc_5:* = multyply3;
            var _loc_13:* = this.particleList.length;
            var _loc_14:* = _loc_13 > maxNum ? (maxNum) : (_loc_13);
            _loc_8 = 0;
            while (_loc_8 < _loc_14)
            {
                
                _loc_6 = this.particleList[_loc_8];
                _loc_7 = _loc_6.visible;
                _loc_9 = _loc_6.startRotate;
                _loc_10 = _loc_6.resultRotate2;
                _loc_11 = _loc_6.resultPos;
                _loc_12 = _loc_6.startPos;
                this._data1[_loc_1] = int(_loc_11.x * _loc_5) * _loc_2 + _loc_9.x + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_11.y * _loc_5) * _loc_2 + _loc_9.y + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_11.z * _loc_5) * _loc_2 + _loc_9.z + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_6.uOffset * _loc_4) * _loc_2 + _loc_6.size * _loc_7 + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_12.x * _loc_5) * _loc_2 + _loc_10.x + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_12.y * _loc_5) * _loc_2 + _loc_10.y + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_12.z * _loc_5) * _loc_2 + _loc_10.z + 1;
                _loc_1++;
                this._data1[_loc_1] = int(_loc_6.vOffset * _loc_4) * _loc_2 + _loc_10.w + 1;
                _loc_1++;
                _loc_8++;
            }
            var _loc_16:* = _loc_13 - maxNum;
            if (_loc_16 <= 0)
            {
                return;
            }
            _loc_1 = 0;
            _loc_13 = _loc_13 > maxNum * 2 ? (maxNum * 2) : (_loc_13);
            _loc_8 = _loc_14;
            while (_loc_8 < _loc_13)
            {
                
                _loc_6 = this.particleList[_loc_8];
                _loc_7 = _loc_6.visible;
                _loc_9 = _loc_6.startRotate;
                _loc_10 = _loc_6.resultRotate2;
                _loc_11 = _loc_6.resultPos;
                _loc_12 = _loc_6.startPos;
                this._data2[_loc_1] = int(_loc_11.x * _loc_5) * _loc_2 + _loc_9.x + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_11.y * _loc_5) * _loc_2 + _loc_9.y + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_11.z * _loc_5) * _loc_2 + _loc_9.z + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_6.uOffset * _loc_4) * _loc_2 + _loc_6.size * _loc_7 + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_12.x * _loc_5) * _loc_2 + _loc_10.x + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_12.y * _loc_5) * _loc_2 + _loc_10.y + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_12.z * _loc_5) * _loc_2 + _loc_10.z + 1;
                _loc_1++;
                this._data2[_loc_1] = int(_loc_6.vOffset * _loc_4) * _loc_2 + _loc_10.w + 1;
                _loc_1++;
                _loc_8++;
            }
            return;
        }// end function

        public function draw(param1:VcParam, param2:Mesh3D, param3:FrSurface3D) : void
        {
            if (this.globalPos == null)
            {
                return;
            }
            param1.value = this._data1;
            var _loc_4:* = this.particleList.length;
            var _loc_5:* = _loc_4 > maxNum ? (maxNum) : (_loc_4);
            var _loc_6:* = this._particleParams.numOfmeshTriangle * _loc_5;
            var _loc_7:* = param2.material.materialParams;
            param2.material.draw(param2, param3, _loc_7.depthCompare, _loc_7.cullFace, _loc_7.depthWrite, _loc_7.sourceFactor, _loc_7.destFactor, 0, _loc_6);
            var _loc_8:* = _loc_4 - maxNum;
            if (_loc_8 <= 0)
            {
                return;
            }
            param1.value = this._data2;
            var _loc_9:* = _loc_6 * 3;
            _loc_6 = (_loc_4 - _loc_5) * this._particleParams.numOfmeshTriangle;
            param2.material.draw(param2, param3, _loc_7.depthCompare, _loc_7.cullFace, _loc_7.depthWrite, _loc_7.sourceFactor, _loc_7.destFactor, _loc_9, _loc_6);
            return;
        }// end function

        private function updateUseEndPoint(param1:Vector3D) : void
        {
            var _loc_8:ParticleItem = null;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:Quaternion = null;
            var _loc_12:Quaternion = null;
            var _loc_13:Vector3D = null;
            var _loc_14:Vector3D = null;
            var _loc_16:Number = NaN;
            var _loc_2:int = 0;
            var _loc_3:* = this.particleList.length;
            var _loc_4:* = multyply0;
            var _loc_5:* = multyply1;
            var _loc_6:* = multyply2;
            var _loc_7:* = multyply3;
            var _loc_15:* = _loc_3 > maxNum ? (maxNum) : (_loc_3);
            var _loc_17:* = this._particleParams.numOfmeshTriangle * _loc_15;
            _loc_10 = 0;
            while (_loc_10 < _loc_15)
            {
                
                _loc_8 = this.particleList[_loc_10];
                _loc_9 = _loc_8.visible;
                _loc_11 = _loc_8.startRotate;
                _loc_12 = _loc_8.resultRotate2;
                _loc_13 = _loc_8.resultPos;
                _loc_14 = _loc_8.startPos;
                this._data1[_loc_2] = int(_loc_13.x * _loc_7) * _loc_4 + _loc_11.x + 1;
                _loc_2++;
                this._data1[_loc_2] = int(_loc_13.y * _loc_7) * _loc_4 + _loc_11.y + 1;
                _loc_2++;
                this._data1[_loc_2] = int(_loc_13.z * _loc_7) * _loc_4 + _loc_11.z + 1;
                _loc_2++;
                this._data1[_loc_2] = int(_loc_8.uOffset * _loc_6) * _loc_4 + _loc_8.size * _loc_9 + 1;
                _loc_2++;
                _loc_16 = _loc_8.lifeRate;
                this._data1[_loc_2] = int((_loc_14.x + (param1.x - _loc_14.x) * _loc_16) * _loc_7) * _loc_4 + _loc_12.x + 1;
                _loc_2++;
                this._data1[_loc_2] = int((_loc_14.y + (param1.y - _loc_14.y) * _loc_16) * _loc_7) * _loc_4 + _loc_12.y + 1;
                _loc_2++;
                this._data1[_loc_2] = int((_loc_14.z + (param1.z - _loc_14.z) * _loc_16) * _loc_7) * _loc_4 + _loc_12.z + 1;
                _loc_2++;
                this._data1[_loc_2] = int(_loc_8.vOffset * _loc_6) * _loc_4 + _loc_12.w + 1;
                _loc_2++;
                _loc_10++;
            }
            var _loc_18:* = _loc_3 - maxNum;
            if (_loc_18 <= 0)
            {
                return;
            }
            _loc_2 = 0;
            _loc_3 = _loc_3 > maxNum * 2 ? (maxNum * 2) : (_loc_3);
            _loc_10 = _loc_15;
            while (_loc_10 < _loc_3)
            {
                
                _loc_8 = this.particleList[_loc_10];
                _loc_9 = _loc_8.visible;
                _loc_11 = _loc_8.startRotate;
                _loc_12 = _loc_8.resultRotate2;
                _loc_13 = _loc_8.resultPos;
                _loc_14 = _loc_8.startPos;
                this._data2[_loc_2] = int(_loc_13.x * _loc_7) * _loc_4 + _loc_11.x + 1;
                _loc_2++;
                this._data2[_loc_2] = int(_loc_13.y * _loc_7) * _loc_4 + _loc_11.y + 1;
                _loc_2++;
                this._data2[_loc_2] = int(_loc_13.z * _loc_7) * _loc_4 + _loc_11.z + 1;
                _loc_2++;
                this._data2[_loc_2] = int(_loc_8.uOffset * _loc_6) * _loc_4 + _loc_8.size * _loc_9 + 1;
                _loc_2++;
                _loc_16 = _loc_8.lifeRate;
                this._data2[_loc_2] = int((_loc_14.x + (param1.x - _loc_14.x) * _loc_16) * _loc_7) * _loc_4 + _loc_12.x + 1;
                _loc_2++;
                this._data2[_loc_2] = int((_loc_14.y + (param1.y - _loc_14.y) * _loc_16) * _loc_7) * _loc_4 + _loc_12.y + 1;
                _loc_2++;
                this._data2[_loc_2] = int((_loc_14.z + (param1.z - _loc_14.z) * _loc_16) * _loc_7) * _loc_4 + _loc_12.z + 1;
                _loc_2++;
                this._data2[_loc_2] = int(_loc_8.vOffset * _loc_6) * _loc_4 + _loc_12.w + 1;
                _loc_2++;
                _loc_10++;
            }
            return;
        }// end function

        private function updateInertiaItems() : void
        {
            var _loc_3:int = 0;
            var _loc_4:ParticleItem = null;
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_1:* = this.particleList.length;
            var _loc_2:* = this._particleParams.maxDuring;
            var _loc_7:* = this._particleParams.emitterLife;
            var _loc_8:* = this.particleList[(_loc_1 - 1)];
            _loc_3 = 0;
            while (_loc_3 < _loc_1)
            {
                
                _loc_4 = this.particleList[_loc_3];
                if (!_loc_4.isPlaying)
                {
                }
                else
                {
                    if (this._useTimeGrowth)
                    {
                        if (this._curFrame > _loc_4.emmiteFrame)
                        {
                            var _loc_9:int = 1;
                            _loc_4.visible = 1;
                        }
                        else if (_loc_4.visible)
                        {
                            _loc_4.visible = 0;
                        }
                    }
                    if (_loc_4.visible)
                    {
                        _loc_5 = this._curFrame - _loc_4.emmiteFrame;
                        _loc_6 = _loc_5 < 0 ? (-1) : (int(_loc_5 / _loc_7));
                        if (_loc_6 != _loc_4.circle)
                        {
                            _loc_4.circle = _loc_6;
                            if (_loc_6 >= _loc_2)
                            {
                                _loc_4.visible = 0;
                                _loc_4.isPlaying = false;
                            }
                            else
                            {
                                _loc_4.reinit(this.globalPos, this.gRotate, this.tailEnabled);
                                if (_loc_8.visible && _loc_8.circle >= 0)
                                {
                                    _loc_4.inertiaDirection.x = int(this.globalPos.x - _loc_8.startPos.x);
                                    _loc_4.inertiaDirection.y = int(this.globalPos.y - _loc_8.startPos.y);
                                    _loc_4.inertiaDirection.z = int(this.globalPos.z - _loc_8.startPos.z);
                                }
                            }
                        }
                        _loc_5 = _loc_5 % _loc_7;
                        var _loc_9:* = _loc_5 + _loc_7;
                        _loc_5 = _loc_5 + _loc_7;
                        _loc_4.toUpdate = _loc_4.curFrame != _loc_5;
                        _loc_4.curFrame = _loc_5;
                        _loc_4.lifeRate = _loc_4.curFrame / _loc_4.life;
                        if (_loc_4.lifeRate > 1)
                        {
                            _loc_4.visible = 0;
                        }
                    }
                    _loc_8 = _loc_4;
                }
                _loc_3++;
            }
            return;
        }// end function

        private function updateNotInertiaItems() : void
        {
            var _loc_3:int = 0;
            var _loc_4:ParticleItem = null;
            var _loc_5:int = 0;
            var _loc_6:int = 0;
            var _loc_1:* = this.particleList.length;
            var _loc_2:* = this._particleParams.maxDuring;
            var _loc_7:* = this._particleParams.emitterLife;
            _loc_3 = 0;
            while (_loc_3 < _loc_1)
            {
                
                _loc_4 = this.particleList[_loc_3];
                if (!_loc_4.isPlaying)
                {
                }
                else
                {
                    if (this._useTimeGrowth)
                    {
                        if (this._curFrame > _loc_4.emmiteFrame)
                        {
                            if (!_loc_4.visible)
                            {
                                _loc_4.visible = 1;
                            }
                        }
                        else if (_loc_4.visible)
                        {
                            _loc_4.visible = 0;
                        }
                    }
                    else
                    {
                        _loc_4.visible = 1;
                    }
                    if (_loc_4.visible)
                    {
                        _loc_5 = this._curFrame - _loc_4.emmiteFrame;
                        _loc_6 = _loc_5 < 0 ? (-1) : (int(_loc_5 / _loc_7));
                        if (_loc_6 != _loc_4.circle)
                        {
                            _loc_4.circle = _loc_6;
                            if (_loc_6 >= _loc_2)
                            {
                                _loc_4.visible = 0;
                                _loc_4.isPlaying = false;
                            }
                            else
                            {
                                _loc_4.reinit(this.globalPos, this.gRotate, this.tailEnabled);
                            }
                        }
                        _loc_5 = _loc_5 % _loc_7;
                        var _loc_8:* = _loc_5 + _loc_7;
                        _loc_5 = _loc_5 + _loc_7;
                        _loc_4.toUpdate = _loc_4.curFrame != _loc_5;
                        _loc_4.curFrame = _loc_5;
                        _loc_4.lifeRate = _loc_4.curFrame / _loc_4.life;
                        if (_loc_4.lifeRate >= 1)
                        {
                            _loc_4.visible = 0;
                        }
                    }
                }
                _loc_3++;
            }
            return;
        }// end function

        private function updateAnims() : void
        {
            var _loc_3:IParticleAnimate = null;
            var _loc_1:* = this._animList.length;
            var _loc_2:int = 0;
            while (_loc_2 < _loc_1)
            {
                
                _loc_3 = this._animList[_loc_2];
                _loc_3.update(this);
                _loc_2++;
            }
            return;
        }// end function

        public function update(param1:int, param2:Vector3D, param3:Quaternion, param4:Vector3D, param5:LineRoadControler) : void
        {
            if (param1 < this._curFrame)
            {
                this.reset(false);
            }
            this._curFrame = param1;
            this.globalPos = param2;
            this.gRotate = param3;
            if (this.inertiaValue)
            {
                this.updateInertiaItems();
            }
            else
            {
                this.updateNotInertiaItems();
            }
            this.updateAnims();
            if (this.useEndPoint)
            {
            }
            else if (this.inertiaValue)
            {
                this.updateInertia();
            }
            else
            {
                this.updateNotInertia();
            }
            return;
        }// end function

        private static function initAnimList() : Array
        {
            var _loc_1:* = new Array();
            _loc_1.push(UseLineSpeed.instance);
            _loc_1.push(UseUvOffset.instance);
            _loc_1.push(UseUvStep.instance);
            _loc_1.push(UseParticleSize.instance);
            _loc_1.push(useFadeAndGrowth.instance);
            _loc_1.push(UseAutoRotate.instance);
            _loc_1.push(UseRotateAsix.instance);
            _loc_1.push(UseLineForce.instance);
            _loc_1.push(UseSimpleHarmonicVibration.instance);
            _loc_1.push(UseLiXinForce.instance);
            _loc_1.push(UseRotateToVelocity.instance);
            _loc_1.push(ResultSelfRotate.instance);
            return _loc_1;
        }// end function

    }
}
